/* src/interfaces/ecpg/preproc/type.c */

#include "postgres_fe.h"

#include "preproc_extern.h"

#define indicator_set fc_ind_type != NULL && fc_ind_type->type != ECPGt_NO_INDICATOR

static struct ECPGstruct_member struct_no_indicator = {"no_indicator", &ecpg_no_indicator, NULL};

/* malloc + 错误检查 */
void * mm_alloc(size_t fc_size)
{
	void	   *fc_ptr = malloc(fc_size);

	if (fc_ptr == NULL)
		mmfatal(OUT_OF_MEMORY, "out of memory");

	return fc_ptr;
}

/* strdup + 错误检查 */
char * mm_strdup(const char *fc_string)
{
	char	   *fc_new = strdup(fc_string);

	if (fc_new == NULL)
		mmfatal(OUT_OF_MEMORY, "out of memory");

	return fc_new;
}

/* 复制成员列表 */
struct ECPGstruct_member *
ECPGstruct_member_dup(struct ECPGstruct_member *fc_rm)
{
	struct ECPGstruct_member *fc_new = NULL;

	while (fc_rm)
	{
		struct ECPGtype *fc_type;

		switch (fc_rm->type->type)
		{
			case ECPGt_struct:
			case ECPGt_union:
				fc_type = ECPGmake_struct_type(fc_rm->type->u.members, fc_rm->type->type, fc_rm->type->type_name, fc_rm->type->struct_sizeof);
				break;
			case ECPGt_array:

				/*
				 * 如果这个数组里再次包含一个结构体，我们必须
				 * 也创建这个结构体
				 */
				if (fc_rm->type->u.element->type == ECPGt_struct || fc_rm->type->u.element->type == ECPGt_union)
					fc_type = ECPGmake_struct_type(fc_rm->type->u.element->u.members, fc_rm->type->u.element->type, fc_rm->type->u.element->type_name, fc_rm->type->u.element->struct_sizeof);
				else
					fc_type = ECPGmake_array_type(ECPGmake_simple_type(fc_rm->type->u.element->type, fc_rm->type->u.element->size, fc_rm->type->u.element->counter), fc_rm->type->size);
				break;
			default:
				fc_type = ECPGmake_simple_type(fc_rm->type->type, fc_rm->type->size, fc_rm->type->counter);
				break;
		}

		ECPGmake_struct_member(fc_rm->name, fc_type, &fc_new);

		fc_rm = fc_rm->next;
	}

	return fc_new;
}

/* NAME 参数被复制。类型参数作为指针保留。 */
void ECPGmake_struct_member(const char *fc_name, struct ECPGtype *fc_type, struct ECPGstruct_member **fc_start)
{
	struct ECPGstruct_member *fc_ptr,
			   *fc_ne =
	(struct ECPGstruct_member *) mm_alloc(sizeof(struct ECPGstruct_member));

	fc_ne->name = mm_strdup(fc_name);
	fc_ne->type = fc_type;
	fc_ne->next = NULL;

	for (fc_ptr = *fc_start; fc_ptr && fc_ptr->next; fc_ptr = fc_ptr->next);

	if (fc_ptr)
		fc_ptr->next = fc_ne;
	else
		*fc_start = fc_ne;
}

struct ECPGtype * ECPGmake_simple_type(enum ECPGttype fc_type, char *fc_size, int fc_counter)
{
	struct ECPGtype *fc_ne = (struct ECPGtype *) mm_alloc(sizeof(struct ECPGtype));

	fc_ne->type = fc_type;
	fc_ne->type_name = NULL;
	fc_ne->size = fc_size;
	fc_ne->u.element = NULL;
	fc_ne->struct_sizeof = NULL;
	fc_ne->counter = fc_counter;		/* 仅针对 varchar 和 bytea 需要 */

	return fc_ne;
}

struct ECPGtype * ECPGmake_array_type(struct ECPGtype *fc_type, char *fc_size)
{
	struct ECPGtype *fc_ne = ECPGmake_simple_type(ECPGt_array, fc_size, 0);

	fc_ne->u.element = fc_type;

	return fc_ne;
}

struct ECPGtype * ECPGmake_struct_type(struct ECPGstruct_member *fc_rm, enum ECPGttype fc_type, char *fc_type_name, char *fc_struct_sizeof)
{
	struct ECPGtype *fc_ne = ECPGmake_simple_type(fc_type, mm_strdup("1"), 0);

	fc_ne->type_name = mm_strdup(fc_type_name);
	fc_ne->u.members = ECPGstruct_member_dup(fc_rm);
	fc_ne->struct_sizeof = fc_struct_sizeof;

	return fc_ne;
}

static const char * fc_get_type(enum ECPGttype fc_type)
{
	switch (fc_type)
	{
		case ECPGt_char:
			return "ECPGt_char";
			break;
		case ECPGt_unsigned_char:
			return "ECPGt_unsigned_char";
			break;
		case ECPGt_short:
			return "ECPGt_short";
			break;
		case ECPGt_unsigned_short:
			return "ECPGt_unsigned_short";
			break;
		case ECPGt_int:
			return "ECPGt_int";
			break;
		case ECPGt_unsigned_int:
			return "ECPGt_unsigned_int";
			break;
		case ECPGt_long:
			return "ECPGt_long";
			break;
		case ECPGt_unsigned_long:
			return "ECPGt_unsigned_long";
			break;
		case ECPGt_long_long:
			return "ECPGt_long_long";
			break;
		case ECPGt_unsigned_long_long:
			return "ECPGt_unsigned_long_long";
			break;
		case ECPGt_float:
			return "ECPGt_float";
			break;
		case ECPGt_double:
			return "ECPGt_double";
			break;
		case ECPGt_bool:
			return "ECPGt_bool";
			break;
		case ECPGt_varchar:
			return "ECPGt_varchar";
		case ECPGt_bytea:
			return "ECPGt_bytea";
		case ECPGt_NO_INDICATOR:	/* 没有指示符 */
			return "ECPGt_NO_INDICATOR";
			break;
		case ECPGt_char_variable:	/* 不应该被引号括起来的字符串 */
			return "ECPGt_char_variable";
			break;
		case ECPGt_const:		/* 常量字符串被引号括起来 */
			return "ECPGt_const";
			break;
		case ECPGt_decimal:
			return "ECPGt_decimal";
			break;
		case ECPGt_numeric:
			return "ECPGt_numeric";
			break;
		case ECPGt_interval:
			return "ECPGt_interval";
			break;
		case ECPGt_descriptor:
			return "ECPGt_descriptor";
			break;
		case ECPGt_sqlda:
			return "ECPGt_sqlda";
			break;
		case ECPGt_date:
			return "ECPGt_date";
			break;
		case ECPGt_timestamp:
			return "ECPGt_timestamp";
			break;
		case ECPGt_string:
			return "ECPGt_string";
			break;
		default:
			mmerror(PARSE_ERROR, ET_ERROR, "unrecognized variable type code %d", fc_type);
	}

	return NULL;
}

/* 转储一个类型。
   这个类型被转储为：
   type-tag <逗号>				   - enum ECPGttype
   对变量的引用 <逗号>		   - char *
   大小 <逗号>					   - long 这个字段的大小（如果是 varchar）
   arrsize <逗号>				   - long 数组中元素的数量
   偏移 <逗号>				   - 下一个元素的偏移量
   其中：
   type-tag 是简单类型或 varchar 之一。
   对变量的引用可以是对结构元素的引用。
   arrsize 是在数组提取的情况下数组的大小。否则为 0。
   size 是在它是一个 varchar 的情况下的最大大小。否则它是
   变量的大小（进行结构的数组提取所需）。
 */
static void fc_ECPGdump_a_simple(FILE *fc_o, const char *fc_name, enum ECPGttype fc_type,
							  char *fc_varcharsize,
							  char *fc_arrsize, const char *fc_size, const char *fc_prefix, int);
static void fc_ECPGdump_a_struct(FILE *fc_o, const char *fc_name, const char *fc_ind_name, char *fc_arrsize,
							  struct ECPGtype *fc_type, struct ECPGtype *fc_ind_type, const char *fc_prefix, const char *fc_ind_prefix);

void ECPGdump_a_type(FILE *fc_o, const char *fc_name, struct ECPGtype *fc_type, const int fc_brace_level,
				const char *fc_ind_name, struct ECPGtype *fc_ind_type, const int fc_ind_brace_level,
				const char *fc_prefix, const char *fc_ind_prefix,
				char *fc_arr_str_size, const char *fc_struct_sizeof,
				const char *fc_ind_struct_sizeof)
{
	struct variable *fc_var;

	if (fc_type->type != ECPGt_descriptor && fc_type->type != ECPGt_sqlda &&
		fc_type->type != ECPGt_char_variable && fc_type->type != ECPGt_const &&
		fc_brace_level >= 0)
	{
		char	   *fc_str;

		fc_str = mm_strdup(fc_name);
		fc_var = find_variable(fc_str);
		free(fc_str);

		if ((fc_var->type->type != fc_type->type) ||
			(fc_var->type->type_name && !fc_type->type_name) ||
			(!fc_var->type->type_name && fc_type->type_name) ||
			(fc_var->type->type_name && fc_type->type_name && strcmp(fc_var->type->type_name, fc_type->type_name) != 0))
			mmerror(PARSE_ERROR, ET_ERROR, "variable \"%s\" is hidden by a local variable of a different type", fc_name);
		else if (fc_var->brace_level != fc_brace_level)
			mmerror(PARSE_ERROR, ET_WARNING, "variable \"%s\" is hidden by a local variable", fc_name);

		if (fc_ind_name && fc_ind_type && fc_ind_type->type != ECPGt_NO_INDICATOR && fc_ind_brace_level >= 0)
		{
			fc_str = mm_strdup(fc_ind_name);
			fc_var = find_variable(fc_str);
			free(fc_str);

			if ((fc_var->type->type != fc_ind_type->type) ||
				(fc_var->type->type_name && !fc_ind_type->type_name) ||
				(!fc_var->type->type_name && fc_ind_type->type_name) ||
				(fc_var->type->type_name && fc_ind_type->type_name && strcmp(fc_var->type->type_name, fc_ind_type->type_name) != 0))
				mmerror(PARSE_ERROR, ET_ERROR, "indicator variable \"%s\" is hidden by a local variable of a different type", fc_ind_name);
			else if (fc_var->brace_level != fc_ind_brace_level)
				mmerror(PARSE_ERROR, ET_WARNING, "indicator variable \"%s\" is hidden by a local variable", fc_ind_name);
		}
	}

	switch (fc_type->type)
	{
		case ECPGt_array:
			if (indicator_set && fc_ind_type->type != ECPGt_array)
				mmfatal(INDICATOR_NOT_ARRAY, "indicator for array/pointer has to be array/pointer");
			switch (fc_type->u.element->type)
			{
				case ECPGt_array:
					mmerror(PARSE_ERROR, ET_ERROR, "nested arrays are not supported (except strings)"); /* 数组的数组 */
					break;
				case ECPGt_struct:
				case ECPGt_union:
					fc_ECPGdump_a_struct(fc_o, fc_name,
									  fc_ind_name,
									  fc_type->size,
									  fc_type->u.element,
									  (fc_ind_type == NULL) ? NULL : ((fc_ind_type->type == ECPGt_NO_INDICATOR) ? fc_ind_type : fc_ind_type->u.element),
									  fc_prefix, fc_ind_prefix);
					break;
				default:
					if (!IS_SIMPLE_TYPE(fc_type->u.element->type))
						base_yyerror("internal error: unknown datatype, please report this to <" PACKAGE_BUGREPORT ">");

					fc_ECPGdump_a_simple(fc_o, fc_name,
									  fc_type->u.element->type,
									  fc_type->u.element->size, fc_type->size, fc_struct_sizeof ? fc_struct_sizeof : NULL,
									  fc_prefix, fc_type->u.element->counter);

					if (fc_ind_type != NULL)
					{
						if (fc_ind_type->type == ECPGt_NO_INDICATOR)
						{
							char	   *fc_str_neg_one = mm_strdup("-1");

							fc_ECPGdump_a_simple(fc_o, fc_ind_name, fc_ind_type->type, fc_ind_type->size, fc_str_neg_one, NULL, fc_ind_prefix, 0);
							free(fc_str_neg_one);
						}
						else
						{
							fc_ECPGdump_a_simple(fc_o, fc_ind_name, fc_ind_type->u.element->type,
											  fc_ind_type->u.element->size, fc_ind_type->size, NULL, fc_ind_prefix, 0);
						}
					}
			}
			break;
		case ECPGt_struct:
			{
				char	   *fc_str_one = mm_strdup("1");

				if (indicator_set && fc_ind_type->type != ECPGt_struct)
					mmfatal(INDICATOR_NOT_STRUCT, "indicator for struct has to be a struct");

				fc_ECPGdump_a_struct(fc_o, fc_name, fc_ind_name, fc_str_one, fc_type, fc_ind_type, fc_prefix, fc_ind_prefix);
				free(fc_str_one);
			}
			break;
		case ECPGt_union:		/* 无法转储完整的联合体 */
			base_yyerror("type of union has to be specified");
			break;
		case ECPGt_char_variable:
			{
				/*
				 * 为每个分配内存，因为存在代码路径导致值被覆盖。
				 */
				char	   *fc_str_varchar_one = mm_strdup("1");
				char	   *fc_str_arr_one = mm_strdup("1");
				char	   *fc_str_neg_one = mm_strdup("-1");

				if (indicator_set && (fc_ind_type->type == ECPGt_struct || fc_ind_type->type == ECPGt_array))
					mmfatal(INDICATOR_NOT_SIMPLE, "indicator for simple data type has to be simple");

				fc_ECPGdump_a_simple(fc_o, fc_name, fc_type->type, fc_str_varchar_one, (fc_arr_str_size && strcmp(fc_arr_str_size, "0") != 0) ? fc_arr_str_size : fc_str_arr_one, fc_struct_sizeof, fc_prefix, 0);
				if (fc_ind_type != NULL)
					fc_ECPGdump_a_simple(fc_o, fc_ind_name, fc_ind_type->type, fc_ind_type->size, (fc_arr_str_size && strcmp(fc_arr_str_size, "0") != 0) ? fc_arr_str_size : fc_str_neg_one, fc_ind_struct_sizeof, fc_ind_prefix, 0);

				free(fc_str_varchar_one);
				free(fc_str_arr_one);
				free(fc_str_neg_one);
			}
			break;
		case ECPGt_descriptor:
			{
				/*
				 * 为每个分配内存，因为存在代码路径导致值被覆盖。
				 */
				char	   *fc_str_neg_one = mm_strdup("-1");
				char	   *fc_ind_type_neg_one = mm_strdup("-1");

				if (indicator_set && (fc_ind_type->type == ECPGt_struct || fc_ind_type->type == ECPGt_array))
					mmfatal(INDICATOR_NOT_SIMPLE, "indicator for simple data type has to be simple");

				fc_ECPGdump_a_simple(fc_o, fc_name, fc_type->type, NULL, fc_str_neg_one, NULL, fc_prefix, 0);
				if (fc_ind_type != NULL)
					fc_ECPGdump_a_simple(fc_o, fc_ind_name, fc_ind_type->type, fc_ind_type->size, fc_ind_type_neg_one, NULL, fc_ind_prefix, 0);

				free(fc_str_neg_one);
				free(fc_ind_type_neg_one);
			}
			break;
		default:
			{
				/*
				 * 为每个分配内存，因为存在代码路径导致值被覆盖。
				 */
				char	   *fc_str_neg_one = mm_strdup("-1");
				char	   *fc_ind_type_neg_one = mm_strdup("-1");

				if (indicator_set && (fc_ind_type->type == ECPGt_struct || fc_ind_type->type == ECPGt_array))
					mmfatal(INDICATOR_NOT_SIMPLE, "indicator for simple data type has to be simple");

				fc_ECPGdump_a_simple(fc_o, fc_name, fc_type->type, fc_type->size, (fc_arr_str_size && strcmp(fc_arr_str_size, "0") != 0) ? fc_arr_str_size : fc_str_neg_one, fc_struct_sizeof, fc_prefix, fc_type->counter);
				if (fc_ind_type != NULL)
					fc_ECPGdump_a_simple(fc_o, fc_ind_name, fc_ind_type->type, fc_ind_type->size, (fc_arr_str_size && strcmp(fc_arr_str_size, "0") != 0) ? fc_arr_str_size : fc_ind_type_neg_one, fc_ind_struct_sizeof, fc_ind_prefix, 0);

				free(fc_str_neg_one);
				free(fc_ind_type_neg_one);
			}
			break;
	}
}


/* 如果大小为 NULL，则偏移为 0，如果不是，则使用大小作为一个字符串，它表示如果我们在一个结构体数组中所需的偏移。 */
static void fc_ECPGdump_a_simple(FILE *fc_o, const char *fc_name, enum ECPGttype fc_type,
				  char *fc_varcharsize,
				  char *fc_arrsize,
				  const char *fc_size,
				  const char *fc_prefix,
				  int fc_counter)
{
	if (fc_type == ECPGt_NO_INDICATOR)
		fprintf(fc_o, "\n\tECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ");
	else if (fc_type == ECPGt_descriptor)
		/* 请记住，这里的名称已经包含了引号（如果需要） */
		fprintf(fc_o, "\n\tECPGt_descriptor, %s, 1L, 1L, 1L, ", fc_name);
	else if (fc_type == ECPGt_sqlda)
		fprintf(fc_o, "\n\tECPGt_sqlda, &%s, 0L, 0L, 0L, ", fc_name);
	else
	{
		char	   *fc_variable = (char *) mm_alloc(strlen(fc_name) + ((fc_prefix == NULL) ? 0 : strlen(fc_prefix)) + 4);
		char	   *fc_offset = (char *) mm_alloc(strlen(fc_name) + strlen("sizeof(struct varchar_)") + 1 + strlen(fc_varcharsize) + sizeof(int) * CHAR_BIT * 10 / 3);
		char	   *fc_struct_name;

		switch (fc_type)
		{
				/*
				 * 除数组和指针外，我们必须使用 & 运算符
				 */

			case ECPGt_varchar:
			case ECPGt_bytea:

				/*
				 * 除具有给定边界的数组外，我们必须使用指针
				 */
				if (((atoi(fc_arrsize) > 0) ||
					 (atoi(fc_arrsize) == 0 && strcmp(fc_arrsize, "0") != 0)) &&
					fc_size == NULL)
					sprintf(fc_variable, "(%s%s)", fc_prefix ? fc_prefix : "", fc_name);
				else
					sprintf(fc_variable, "&(%s%s)", fc_prefix ? fc_prefix : "", fc_name);

				/*
				 * 如果我们自动创建了一个 varchar 结构，计数器则大于 0。
				 */
				if (fc_type == ECPGt_varchar)
					fc_struct_name = "struct varchar";
				else
					fc_struct_name = "struct bytea";

				if (fc_counter)
					sprintf(fc_offset, "sizeof(%s_%d)", fc_struct_name, fc_counter);
				else
					sprintf(fc_offset, "sizeof(%s)", fc_struct_name);
				break;
			case ECPGt_char:
			case ECPGt_unsigned_char:
			case ECPGt_char_variable:
			case ECPGt_string:
				{
					char	   *fc_sizeof_name = "char";

					/*
					 * 除具有给定边界的数组外，我们必须使用指针，ecpglib 将区分 * 和 []
					 */
					if ((atoi(fc_varcharsize) > 1 ||
						 (atoi(fc_arrsize) > 0) ||
						 (atoi(fc_varcharsize) == 0 && strcmp(fc_varcharsize, "0") != 0) ||
						 (atoi(fc_arrsize) == 0 && strcmp(fc_arrsize, "0") != 0))
						&& fc_size == NULL)
					{
						sprintf(fc_variable, "(%s%s)", fc_prefix ? fc_prefix : "", fc_name);
						if ((fc_type == ECPGt_char || fc_type == ECPGt_unsigned_char) &&
							strcmp(fc_varcharsize, "0") == 0)
						{
							/*
							 * 如果这是一个 char * 的数组，偏移量将是
							 * sizeof(char *) 而不是 sizeof(char)。
							 */
							fc_sizeof_name = "char *";
						}
					}
					else
						sprintf(fc_variable, "&(%s%s)", fc_prefix ? fc_prefix : "", fc_name);

					sprintf(fc_offset, "(%s)*sizeof(%s)", strcmp(fc_varcharsize, "0") == 0 ? "1" : fc_varcharsize, fc_sizeof_name);
					break;
				}
			case ECPGt_numeric:

				/*
				 * 我们在这里必须使用指针
				 */
				sprintf(fc_variable, "&(%s%s)", fc_prefix ? fc_prefix : "", fc_name);
				sprintf(fc_offset, "sizeof(numeric)");
				break;
			case ECPGt_interval:

				/*
				 * 我们在这里必须使用指针
				 */
				sprintf(fc_variable, "&(%s%s)", fc_prefix ? fc_prefix : "", fc_name);
				sprintf(fc_offset, "sizeof(interval)");
				break;
			case ECPGt_date:

				/*
				 * 我们必须使用指针并转换变量类型
				 */
				sprintf(fc_variable, "&(%s%s)", fc_prefix ? fc_prefix : "", fc_name);
				sprintf(fc_offset, "sizeof(date)");
				break;
			case ECPGt_timestamp:

				/*
				 * 我们必须使用指针并转换变量类型
				 */
				sprintf(fc_variable, "&(%s%s)", fc_prefix ? fc_prefix : "", fc_name);
				sprintf(fc_offset, "sizeof(timestamp)");
				break;
			case ECPGt_const:

				/*
				 * 仅将常量转储为字符串
				 */
				sprintf(fc_variable, "\"%s\"", fc_name);
				sprintf(fc_offset, "strlen(\"%s\")", fc_name);
				break;
			default:

				/*
				 * 除具有给定边界的数组外，我们必须使用指针
				 */
				if (((atoi(fc_arrsize) > 0) ||
					 (atoi(fc_arrsize) == 0 && strcmp(fc_arrsize, "0") != 0)) &&
					fc_size == NULL)
					sprintf(fc_variable, "(%s%s)", fc_prefix ? fc_prefix : "", fc_name);
				else
					sprintf(fc_variable, "&(%s%s)", fc_prefix ? fc_prefix : "", fc_name);

				sprintf(fc_offset, "sizeof(%s)", ecpg_type_name(fc_type));
				break;
		}

		/*
		 * 对于结构体内成员的地址，数组大小将为 -1，
		 * 当结构体指针被转储时。
		 */
		if (atoi(fc_arrsize) < 0 && !fc_size)
			strcpy(fc_arrsize, "1");

		/*
		 * 如果大小，即此变量所处结构体的大小，
		 * 给出下一个元素的偏移量（如果需要）
		 */
		if (fc_size == NULL || strlen(fc_size) == 0)
			fprintf(fc_o, "\n\t%s,%s,(long)%s,(long)%s,%s, ", fc_get_type(fc_type), fc_variable, fc_varcharsize, fc_arrsize, fc_offset);
		else
			fprintf(fc_o, "\n\t%s,%s,(long)%s,(long)%s,%s, ", fc_get_type(fc_type), fc_variable, fc_varcharsize, fc_arrsize, fc_size);

		free(fc_variable);
		free(fc_offset);
	}
}


/* 解析一个结构体并转储内容。 */
static void fc_ECPGdump_a_struct(FILE *fc_o, const char *fc_name, const char *fc_ind_name, char *fc_arrsize, struct ECPGtype *fc_type, struct ECPGtype *fc_ind_type, const char *fc_prefix, const char *fc_ind_prefix)
{
	/*
	 * 如果偏移量为 NULL，那么这是第一层递归。如果不是，那么
	 * 我们处于一个结构体中，偏移量被用作偏移。
	 */
	struct ECPGstruct_member *fc_p,
			   *fc_ind_p = NULL;
	char	   *fc_pbuf = (char *) mm_alloc(strlen(fc_name) + ((fc_prefix == NULL) ? 0 : strlen(fc_prefix)) + 3);
	char	   *fc_ind_pbuf = (char *) mm_alloc(strlen(fc_ind_name) + ((fc_ind_prefix == NULL) ? 0 : strlen(fc_ind_prefix)) + 3);

	if (atoi(fc_arrsize) == 1)
		sprintf(fc_pbuf, "%s%s.", fc_prefix ? fc_prefix : "", fc_name);
	else
		sprintf(fc_pbuf, "%s%s->", fc_prefix ? fc_prefix : "", fc_name);

	fc_prefix = fc_pbuf;

	if (fc_ind_type == &ecpg_no_indicator)
		fc_ind_p = &struct_no_indicator;
	else if (fc_ind_type != NULL)
	{
		if (atoi(fc_arrsize) == 1)
			sprintf(fc_ind_pbuf, "%s%s.", fc_ind_prefix ? fc_ind_prefix : "", fc_ind_name);
		else
			sprintf(fc_ind_pbuf, "%s%s->", fc_ind_prefix ? fc_ind_prefix : "", fc_ind_name);

		fc_ind_prefix = fc_ind_pbuf;
		fc_ind_p = fc_ind_type->u.members;
	}

	for (fc_p = fc_type->u.members; fc_p; fc_p = fc_p->next)
	{
		ECPGdump_a_type(fc_o, fc_p->name, fc_p->type, -1,
						(fc_ind_p != NULL) ? fc_ind_p->name : NULL,
						(fc_ind_p != NULL) ? fc_ind_p->type : NULL,
						-1,
						fc_prefix, fc_ind_prefix, fc_arrsize, fc_type->struct_sizeof,
						(fc_ind_p != NULL) ? fc_ind_type->struct_sizeof : NULL);
		if (fc_ind_p != NULL && fc_ind_p != &struct_no_indicator)
		{
			fc_ind_p = fc_ind_p->next;
			if (fc_ind_p == NULL && fc_p->next != NULL)
			{
				mmerror(PARSE_ERROR, ET_WARNING, "indicator struct \"%s\" has too few members", fc_ind_name);
				fc_ind_p = &struct_no_indicator;
			}
		}
	}

	if (fc_ind_type != NULL && fc_ind_p != NULL && fc_ind_p != &struct_no_indicator)
	{
		mmerror(PARSE_ERROR, ET_WARNING, "indicator struct \"%s\" has too many members", fc_ind_name);
	}

	free(fc_pbuf);
	free(fc_ind_pbuf);
}

void ECPGfree_struct_member(struct ECPGstruct_member *fc_rm)
{
	while (fc_rm)
	{
		struct ECPGstruct_member *fc_p = fc_rm;

		fc_rm = fc_rm->next;
		free(fc_p->name);
		free(fc_p->type);
		free(fc_p);
	}
}

void ECPGfree_type(struct ECPGtype *fc_type)
{
	if (!IS_SIMPLE_TYPE(fc_type->type))
	{
		switch (fc_type->type)
		{
			case ECPGt_array:
				switch (fc_type->u.element->type)
				{
					case ECPGt_array:
						base_yyerror("internal error: found multidimensional array\n");
						break;
					case ECPGt_struct:
					case ECPGt_union:
						/* 结构体数组。 */
						ECPGfree_struct_member(fc_type->u.element->u.members);
						free(fc_type->u.element);
						break;
					default:
						if (!IS_SIMPLE_TYPE(fc_type->u.element->type))
							base_yyerror("internal error: unknown datatype, please report this to <" PACKAGE_BUGREPORT ">");

						free(fc_type->u.element);
				}
				break;
			case ECPGt_struct:
			case ECPGt_union:
				ECPGfree_struct_member(fc_type->u.members);
				break;
			default:
				mmerror(PARSE_ERROR, ET_ERROR, "unrecognized variable type code %d", fc_type->type);
				break;
		}
	}
	free(fc_type);
}

const char * get_dtype(enum ECPGdtype fc_type)
{
	switch (fc_type)
	{
		case ECPGd_count:
			return "ECPGd_countr";
			break;
		case ECPGd_data:
			return "ECPGd_data";
			break;
		case ECPGd_di_code:
			return "ECPGd_di_code";
			break;
		case ECPGd_di_precision:
			return "ECPGd_di_precision";
			break;
		case ECPGd_indicator:
			return "ECPGd_indicator";
			break;
		case ECPGd_key_member:
			return "ECPGd_key_member";
			break;
		case ECPGd_length:
			return "ECPGd_length";
			break;
		case ECPGd_name:
			return "ECPGd_name";
			break;
		case ECPGd_nullable:
			return "ECPGd_nullable";
			break;
		case ECPGd_octet:
			return "ECPGd_octet";
			break;
		case ECPGd_precision:
			return "ECPGd_precision";
			break;
		case ECPGd_ret_length:
			return "ECPGd_ret_length";
		case ECPGd_ret_octet:
			return "ECPGd_ret_octet";
			break;
		case ECPGd_scale:
			return "ECPGd_scale";
			break;
		case ECPGd_type:
			return "ECPGd_type";
			break;
		case ECPGd_cardinality:
			return "ECPGd_cardinality";
		default:
			mmerror(PARSE_ERROR, ET_ERROR, "unrecognized descriptor item code %d", fc_type);
	}

	return NULL;
}
